﻿#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "MyDbLogger.h"
#include <ace/OS.h>
#include <ace/Thread.h>

MyDbLogger::MyDbLogger(FILE* f) : file_(f){ }
MyDbLogger::~MyDbLogger() {
	fclose(file_);
}

void MyDbLogger::Logv(const char* format, va_list ap) {
	const uint64_t thread_id = ACE_Thread::self();

	// We try twice: the first time with a fixed-size stack allocated buffer,
	// and the second time with a much larger dynamically allocated buffer.
	char buffer[500];
	for (int iter = 0; iter < 2; iter++) {
		char* base;
		int bufsize;
		if (iter == 0) {
			bufsize = sizeof(buffer);
			base = buffer;
		} else {
			bufsize = 30000;
			base = new char[bufsize];
		}
		char* p = base;
		char* limit = base + bufsize;

		/*struct timeval now_tv;
		gettimeofday(&now_tv, NULL);
		const time_t seconds = now_tv.tv_sec;*/
		struct tm t;
		time_t now;      
		time(&now); 	  
		ACE_OS::localtime_r(&now,&t);
		p += ACE_OS::snprintf(p, limit - p,
			"%04d/%02d/%02d-%02d:%02d:%02d %llx ",
			t.tm_year + 1900,
			t.tm_mon + 1,
			t.tm_mday,
			t.tm_hour,
			t.tm_min,
			t.tm_sec,
			static_cast<long long unsigned int>(thread_id));

		// Print the message
		if (p < limit) {
			va_list backup_ap;
			va_copy(backup_ap, ap);
			p += vsnprintf(p, limit - p, format, backup_ap);
			va_end(backup_ap);
		}

		// Truncate to available space if necessary
		if (p >= limit) {
			if (iter == 0) {
				continue;       // Try again with larger buffer
			} else {
				p = limit - 1;
			}
		}

		// Add newline if necessary
		if (p == base || p[-1] != '\n') {
			*p++ = '\n';
		}

		assert(p <= limit);
		fwrite(base, 1, p - base, file_);
		fflush(file_);
		if (base != buffer) {
			delete[] base;
		}
		break;
	}
}


